juce/source/extras/the jucer/src/model/jucer_PaintRoutine.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 #include "../jucer_Headers.h"
  27 #include "jucer_PaintRoutine.h"
  28 #include "jucer_JucerDocument.h"
  29 #include "jucer_ObjectTypes.h"
  30 #include "paintelements/jucer_PaintElementUndoableAction.h"
  31 #include "paintelements/jucer_PaintElementPath.h"
  32 #include "paintelements/jucer_PaintElementImage.h"
  33 #include "paintelements/jucer_PaintElementGroup.h"
  34 #include "../ui/jucer_JucerDocumentHolder.h"
  35
  36
  37 //==============================================================================
  38 PaintRoutine::PaintRoutine()
  39     : document (0),
  40       backgroundColour (Colours::white)
  41 {
  42     clear();
  43 }
  44
  45 PaintRoutine::~PaintRoutine()
  46 {
  47     elements.clear(); // do this explicitly before the scalar destructor because these
  48                       // objects will be listeners on this object
  49 }
  50
  51 //==============================================================================
  52 void PaintRoutine::changed()
  53 {
  54     if (document != 0)
  55         document->changed();
  56 }
  57
  58 bool PaintRoutine::perform (UndoableAction* action, const String& actionName)
  59 {
  60     jassert (document != 0);
  61
  62     if (document != 0)
  63     {
  64         return document->getUndoManager().perform (action, actionName);
  65     }
  66     else
  67     {
  68         action->perform();
  69         delete action;
  70         return false;
  71     }
  72 }
  73
  74 void PaintRoutine::setBackgroundColour (const Colour& newColour) throw()
  75 {
  76     backgroundColour = newColour;
  77     changed();
  78 }
  79
  80 void PaintRoutine::clear()
  81 {
  82     if (elements.size() > 0)
  83     {
  84         elements.clear();
  85         changed();
  86     }
  87 }
  88
  89 //==============================================================================
  90 class AddXmlElementAction   : public UndoableAction
  91 {
  92 public:
  93     AddXmlElementAction (PaintRoutine& routine_, XmlElement* xml_)
  94         : routine (routine_),
  95           xml (xml_)
  96     {
  97     }
  98
  99     ~AddXmlElementAction()
 100     {
 101         delete xml;
 102     }
 103
 104     bool perform()
 105     {
 106         showCorrectTab();
 107         PaintElement* newElement = routine.addElementFromXml (*xml, -1, false);
 108         jassert (newElement != 0);
 109
 110         indexAdded = routine.indexOfElement (newElement);
 111         jassert (indexAdded >= 0);
 112         return indexAdded >= 0;
 113     }
 114
 115     bool undo()
 116     {
 117         showCorrectTab();
 118         routine.removeElement (routine.getElement (indexAdded), false);
 119         return true;
 120     }
 121
 122     int getSizeInUnits()    { return 10; }
 123
 124     int indexAdded;
 125
 126 private:
 127     PaintRoutine& routine;
 128     XmlElement* xml;
 129
 130     void showCorrectTab() const
 131     {
 132         JucerDocumentHolder* const docHolder = JucerDocumentHolder::getActiveDocumentHolder();
 133
 134         if (docHolder != 0)
 135             docHolder->showGraphics (&routine);
 136     }
 137
 138     AddXmlElementAction (const AddXmlElementAction&);
 139     AddXmlElementAction& operator= (const AddXmlElementAction&);
 140 };
 141
 142 PaintElement* PaintRoutine::addElementFromXml (const XmlElement& xml, const int index, const bool undoable)
 143 {
 144     selectedPoints.deselectAll();
 145
 146     if (undoable)
 147     {
 148         AddXmlElementAction* action = new AddXmlElementAction (*this, new XmlElement (xml));
 149         perform (action, "Add new element");
 150
 151         return elements [action->indexAdded];
 152     }
 153     else
 154     {
 155         PaintElement* const newElement = ObjectTypes::createElementForXml (&xml, this);
 156
 157         if (newElement != 0)
 158         {
 159             elements.insert (index, newElement);
 160             changed();
 161
 162             return newElement;
 163         }
 164     }
 165
 166     return 0;
 167 }
 168
 169 PaintElement* PaintRoutine::addNewElement (PaintElement* e, const int index, const bool undoable)
 170 {
 171     if (e != 0)
 172     {
 173         XmlElement* const xml = e->createXml();
 174         delete e;
 175
 176         e = addElementFromXml (*xml, index, undoable);
 177
 178         delete xml;
 179     }
 180
 181     return e;
 182 }
 183
 184 //==============================================================================
 185 class DeleteElementAction   : public PaintElementUndoableAction <PaintElement>
 186 {
 187 public:
 188     DeleteElementAction (PaintElement* const element)
 189         : PaintElementUndoableAction <PaintElement> (element),
 190           oldIndex (-1)
 191     {
 192         xml = element->createXml();
 193         oldIndex = routine.indexOfElement (element);
 194     }
 195
 196     ~DeleteElementAction()
 197     {
 198         delete xml;
 199     }
 200
 201     bool perform()
 202     {
 203         showCorrectTab();
 204         routine.removeElement (getElement(), false);
 205         return true;
 206     }
 207
 208     bool undo()
 209     {
 210         PaintElement* newElement = routine.addElementFromXml (*xml, oldIndex, false);
 211         showCorrectTab();
 212         return newElement != 0;
 213     }
 214
 215     int getSizeInUnits()    { return 10; }
 216
 217 private:
 218     XmlElement* xml;
 219     int oldIndex;
 220 };
 221
 222
 223 void PaintRoutine::removeElement (PaintElement* element, const bool undoable)
 224 {
 225     if (elements.contains (element))
 226     {
 227         if (undoable)
 228         {
 229             perform (new DeleteElementAction (element),
 230                      "Delete " + element->getTypeName());
 231         }
 232         else
 233         {
 234             selectedElements.deselect (element);
 235             selectedPoints.deselectAll();
 236
 237             selectedPoints.changed (true);
 238             selectedElements.changed (true);
 239
 240             elements.removeObject (element);
 241             changed();
 242         }
 243     }
 244 }
 245
 246 //==============================================================================
 247 class FrontOrBackElementAction  : public PaintElementUndoableAction <PaintElement>
 248 {
 249 public:
 250     FrontOrBackElementAction (PaintElement* const element, int newIndex_)
 251         : PaintElementUndoableAction <PaintElement> (element),
 252           newIndex (newIndex_)
 253     {
 254         oldIndex = routine.indexOfElement (element);
 255     }
 256
 257     bool perform()
 258     {
 259         showCorrectTab();
 260
 261         PaintElement* e = routine.getElement (oldIndex);
 262         routine.moveElementZOrder (oldIndex, newIndex);
 263         newIndex = routine.indexOfElement (e);
 264         return true;
 265     }
 266
 267     bool undo()
 268     {
 269         showCorrectTab();
 270         routine.moveElementZOrder (newIndex, oldIndex);
 271         return true;
 272     }
 273
 274 private:
 275     int newIndex, oldIndex;
 276 };
 277
 278 void PaintRoutine::moveElementZOrder (int oldIndex, int newIndex)
 279 {
 280     jassert (elements [oldIndex] != 0);
 281
 282     if (oldIndex != newIndex && elements [oldIndex] != 0)
 283     {
 284         elements.move (oldIndex, newIndex);
 285         changed();
 286     }
 287 }
 288
 289 void PaintRoutine::elementToFront (PaintElement* element, const bool undoable)
 290 {
 291     if (element != 0 && elements.contains (element))
 292     {
 293         if (undoable)
 294             perform (new FrontOrBackElementAction (element, -1), "Move elements to front");
 295         else
 296             moveElementZOrder (elements.indexOf (element), -1);
 297     }
 298 }
 299
 300 void PaintRoutine::elementToBack (PaintElement* element, const bool undoable)
 301 {
 302     if (element != 0 && elements.contains (element))
 303     {
 304         if (undoable)
 305             perform (new FrontOrBackElementAction (element, 0), "Move elements to back");
 306         else
 307             moveElementZOrder (elements.indexOf (element), 0);
 308     }
 309 }
 310
 311 //==============================================================================
 312 const char* const PaintRoutine::clipboardXmlTag = "PAINTELEMENTS";
 313
 314 void PaintRoutine::copySelectedToClipboard()
 315 {
 316     if (selectedElements.getNumSelected() == 0)
 317         return;
 318
 319     XmlElement clip (clipboardXmlTag);
 320
 321     for (int i = 0; i < elements.size(); ++i)
 322     {
 323         PaintElement* const pe = elements.getUnchecked(i);
 324
 325         if (selectedElements.isSelected (pe))
 326         {
 327             XmlElement* const e = pe->createXml();
 328             clip.addChildElement (e);
 329         }
 330     }
 331
 332     SystemClipboard::copyTextToClipboard (clip.createDocument (String::empty, false, false));
 333 }
 334
 335 void PaintRoutine::paste()
 336 {
 337     XmlDocument clip (SystemClipboard::getTextFromClipboard());
 338     XmlElement* const doc = clip.getDocumentElement();
 339
 340     if (doc != 0 && doc->hasTagName (clipboardXmlTag))
 341     {
 342         selectedElements.deselectAll();
 343         selectedPoints.deselectAll();
 344
 345         forEachXmlChildElement (*doc, e)
 346         {
 347             PaintElement* newElement = addElementFromXml (*e, -1, true);
 348
 349             if (newElement != 0)
 350                 selectedElements.addToSelection (newElement);
 351         }
 352     }
 353
 354     delete doc;
 355 }
 356
 357 void PaintRoutine::deleteSelected()
 358 {
 359     const SelectedItemSet <PaintElement*> temp1 (selectedElements);
 360     const SelectedItemSet <PathPoint*> temp2 (selectedPoints);
 361
 362     if (temp2.getNumSelected() > 0)
 363     {
 364         selectedPoints.deselectAll();
 365         selectedPoints.changed (true); // synchronous message to get rid of any property components
 366
 367         // if any points are selected, just delete them, and not the element, which may
 368         // also be selected..
 369         for (int i = temp2.getNumSelected(); --i >= 0;)
 370             temp2.getSelectedItem (i)->deleteFromPath();
 371
 372         changed();
 373     }
 374     else if (temp1.getNumSelected() > 0)
 375     {
 376         selectedElements.deselectAll();
 377         selectedElements.changed (true);
 378
 379         for (int i = temp1.getNumSelected(); --i >= 0;)
 380             removeElement (temp1.getSelectedItem (i), true);
 381
 382         changed();
 383     }
 384 }
 385
 386 void PaintRoutine::selectAll()
 387 {
 388     if (selectedPoints.getNumSelected() > 0)
 389     {
 390         PaintElementPath* path = selectedPoints.getSelectedItem (0)->owner;
 391
 392         if (path != 0)
 393         {
 394             for (int i = 0; i < path->getNumPoints(); ++i)
 395                 selectedPoints.addToSelection (path->getPoint (i));
 396         }
 397     }
 398     else
 399     {
 400         for (int i = 0; i < elements.size(); ++i)
 401             selectedElements.addToSelection (elements.getUnchecked (i));
 402     }
 403 }
 404
 405 void PaintRoutine::selectedToFront()
 406 {
 407     const SelectedItemSet <PaintElement*> temp (selectedElements);
 408
 409     for (int i = temp.getNumSelected(); --i >= 0;)
 410         elementToFront (temp.getSelectedItem(i), true);
 411 }
 412
 413 void PaintRoutine::selectedToBack()
 414 {
 415     const SelectedItemSet <PaintElement*> temp (selectedElements);
 416
 417     for (int i = 0; i < temp.getNumSelected(); ++i)
 418         elementToBack (temp.getSelectedItem(i), true);
 419 }
 420
 421 void PaintRoutine::groupSelected()
 422 {
 423     PaintElementGroup::groupSelected (this);
 424 }
 425
 426 void PaintRoutine::ungroupSelected()
 427 {
 428     const SelectedItemSet <PaintElement*> temp (selectedElements);
 429
 430     for (int i = 0; i < temp.getNumSelected(); ++i)
 431     {
 432         PaintElementGroup* const pg = dynamic_cast <PaintElementGroup*> (temp.getSelectedItem (i));
 433
 434         if (pg != 0)
 435             pg->ungroup (true);
 436     }
 437 }
 438
 439 void PaintRoutine::bringLostItemsBackOnScreen (const Rectangle<int>& parentArea)
 440 {
 441     for (int i = 0; i < elements.size(); ++i)
 442     {
 443         PaintElement* const c = elements[i];
 444
 445         Rectangle<int> r (c->getCurrentBounds (parentArea));
 446
 447         if (! r.intersects (parentArea))
 448         {
 449             r.setPosition (parentArea.getCentreX(), parentArea.getCentreY());
 450             c->setCurrentBounds (r, parentArea, true);
 451         }
 452     }
 453 }
 454
 455 void PaintRoutine::startDragging (const Rectangle<int>& parentArea)
 456 {
 457     for (int i = 0; i < elements.size(); ++i)
 458     {
 459         PaintElement* const c = elements[i];
 460
 461         Rectangle<int> r (c->getCurrentBounds (parentArea));
 462
 463         c->getProperties().set ("xDragStart", r.getX());
 464         c->getProperties().set ("yDragStart", r.getY());
 465     }
 466
 467     getDocument()->getUndoManager().beginNewTransaction();
 468 }
 469
 470 void PaintRoutine::dragSelectedComps (int dx, int dy, const Rectangle<int>& parentArea)
 471 {
 472     getDocument()->getUndoManager().undoCurrentTransactionOnly();
 473
 474     if (document != 0 && selectedElements.getNumSelected() > 1)
 475     {
 476         dx = document->snapPosition (dx);
 477         dy = document->snapPosition (dy);
 478     }
 479
 480     for (int i = 0; i < selectedElements.getNumSelected(); ++i)
 481     {
 482         PaintElement* const c = selectedElements.getSelectedItem (i);
 483
 484         const int startX = c->getProperties() ["xDragStart"];
 485         const int startY = c->getProperties() ["yDragStart"];
 486
 487         Rectangle<int> r (c->getCurrentBounds (parentArea));
 488
 489         if (document != 0 && selectedElements.getNumSelected() == 1)
 490         {
 491             r.setPosition (document->snapPosition (startX + dx),
 492                            document->snapPosition (startY + dy));
 493         }
 494         else
 495         {
 496             r.setPosition (startX + dx,
 497                            startY + dy);
 498         }
 499
 500         c->setCurrentBounds (r, parentArea, true);
 501     }
 502
 503     changed();
 504 }
 505
 506 void PaintRoutine::endDragging()
 507 {
 508     getDocument()->getUndoManager().beginNewTransaction();
 509 }
 510
 511 //==============================================================================
 512 void PaintRoutine::fillWithBackground (Graphics& g, const bool drawOpaqueBackground)
 513 {
 514     if ((! backgroundColour.isOpaque()) && drawOpaqueBackground)
 515     {
 516         g.fillCheckerBoard (Rectangle<int> (0, 0, g.getClipBounds().getRight(), g.getClipBounds().getBottom()),
 517                             50, 50,
 518                             Colour (0xffdddddd).overlaidWith (backgroundColour),
 519                             Colour (0xffffffff).overlaidWith (backgroundColour));
 520     }
 521     else
 522     {
 523         g.fillAll (backgroundColour);
 524     }
 525 }
 526
 527 void PaintRoutine::drawElements (Graphics& g, const Rectangle<int>& relativeTo)
 528 {
 529     Component temp;
 530     temp.setBounds (relativeTo);
 531
 532     for (int i = 0; i < elements.size(); ++i)
 533         elements.getUnchecked (i)->draw (g, getDocument()->getComponentLayout(), relativeTo);
 534 }
 535
 536 //==============================================================================
 537 void PaintRoutine::dropImageAt (const File& f, int x, int y)
 538 {
 539     Drawable* d = Drawable::createFromImageFile (f);
 540
 541     if (d != 0)
 542     {
 543         Rectangle<float> bounds (d->getDrawableBounds());
 544         delete d;
 545
 546         PaintElement* newElement
 547             = addNewElement (ObjectTypes::createNewImageElement (this), -1, true);
 548
 549         PaintElementImage* pei = dynamic_cast <PaintElementImage*> (newElement);
 550
 551         if (pei != 0)
 552         {
 553             String resourceName (getDocument()->getResources().findUniqueName (f.getFileName()));
 554
 555             const BinaryResources::BinaryResource* existingResource = getDocument()->getResources().getResourceForFile (f);
 556
 557             if (existingResource != 0)
 558             {
 559                 resourceName = existingResource->name;
 560             }
 561             else
 562             {
 563                 MemoryBlock data;
 564                 f.loadFileAsData (data);
 565
 566                 getDocument()->getResources().add (resourceName, f.getFullPathName(), data);
 567             }
 568
 569             pei->setResource (resourceName, true);
 570
 571             const int imageW = (int) (bounds.getRight() + 0.999f);
 572             const int imageH = (int) (bounds.getBottom() + 0.999f);
 573
 574             RelativePositionedRectangle pr;
 575             pr.rect.setX (x - imageW / 2);
 576             pr.rect.setY (y - imageH / 2);
 577             pr.rect.setWidth (imageW);
 578             pr.rect.setHeight (imageH);
 579
 580             pei->setPosition (pr, true);
 581
 582             getSelectedElements().selectOnly (pei);
 583         }
 584     }
 585 }
 586
 587 //==============================================================================
 588 const char* PaintRoutine::xmlTagName = "BACKGROUND";
 589
 590 XmlElement* PaintRoutine::createXml() const
 591 {
 592     XmlElement* const xml = new XmlElement (xmlTagName);
 593
 594     xml->setAttribute ("backgroundColour", colourToHex (backgroundColour));
 595
 596     for (int i = 0; i < elements.size(); ++i)
 597         xml->addChildElement (elements.getUnchecked (i)->createXml());
 598
 599     return xml;
 600 }
 601
 602 bool PaintRoutine::loadFromXml (const XmlElement& xml)
 603 {
 604     if (xml.hasTagName (xmlTagName))
 605     {
 606         backgroundColour = Colour (xml.getStringAttribute ("backgroundColour", colourToHex (Colours::white)).getHexValue32());
 607
 608         clear();
 609
 610         forEachXmlChildElement (xml, e)
 611         {
 612             PaintElement* const newElement = ObjectTypes::createElementForXml (e, this);
 613
 614             if (newElement != 0)
 615                 elements.add (newElement);
 616         }
 617
 618         return true;
 619     }
 620
 621     return false;
 622 }
 623
 624 void PaintRoutine::fillInGeneratedCode (GeneratedCode& code, String& paintMethodCode) const
 625 {
 626     if (! backgroundColour.isTransparent())
 627         paintMethodCode << "g.fillAll (" << colourToCode (backgroundColour) << ");\n\n";
 628
 629     for (int i = 0; i < elements.size(); ++i)
 630         elements[i]->fillInGeneratedCode (code, paintMethodCode);
 631 }